;;;======================================================
;;;   Rule Based Recomandation System
;;;     
;;;     Recomnds which method to use for a given 
;;;		system properties.
;;;          eg. F(x)=0
;;;       
;;;     To execute, merely load, reset and run.
;;;     
;;;======================================================

(defrule startup
  =>
  (clear)
 	  
 )
 
;;;======================================================
;;;       
;;;     				 deftemplate for F(X) properties
;;;     
;;;======================================================		  

(deftemplate dimensiunea_sistemului (slot dimens (type INTEGER)))
(deftemplate jacobianul_sistemului (slot jacobian (type INTEGER)))
(deftemplate forma_sistemului (slot forma (type STRING)))
(deftemplate grad_linearitate_al_sistemului (slot grad_lin (type STRING)))
(deftemplate solutia_sistemului (slot solutie (type STRING)))

;;;======================================================
;;;       
;;;     				 define F(X) properties
;;;     
;;;======================================================		  
  (assert (dimensiunea_sistemului (dimens 3)))
  ;dimensiunea sistemului n poate avea orice valori : mica (n < 10), medie (10 < n < 50) , mare (50 < n < 500) sau foarte mare (500 < n)
  
  (assert (jacobianul_sistemului (jacobian 100)))
  ;jacobianul poate avea orice valori aproximative
  
  (assert (forma_sistemului (forma generala)))
  ; forma sistemului : generala , lacunara , diagonal_explicita , suma sau speciala
  
  (assert (grad_linearitate_al_sistemului (grad_lin oarecare)))
  ; gradul de linearitate al sistemului : oarecare sau slab_neliniar 
  
	
;;;======================================================
;;;       
;;;     				 define rule for output solution
;;;     
;;;======================================================		  

(defrule solutie 
(solutia_sistemului (solutie ?metoda)) 
=> (printout t "Metoda recomandata este : " ?metoda " ." crlf))

;;;======================================================
;;;       
;;;     				 define rule for Newton clasica
;;;     
;;;======================================================	
(defrule cauta_NC
	(dimensiunea_sistemului  {dimens < 10})
	(jacobianul_sistemului {jacobian != 0})
	(forma_sistemului {forma == generala})
	(grad_linearitate_al_sistemului {grad_lin == oarecare})
	=>
	(assert (solutia_sistemului (solutie Newton_clasica)))
)	
  
;;;======================================================
;;;       
;;;     				 define rule for Newton discret
;;;     
;;;======================================================	
(defrule cauta_ND
	(dimensiunea_sistemului  {dimens     <  10 })
	(jacobianul_sistemului {jacobian != 0})
	(forma_sistemului {forma == generala})
	(grad_linearitate_al_sistemului {grad_lin == oarecare})
	=>
	(assert (solutia_sistemului (solutie Newton_discret)))
)	
;;;======================================================
;;;       
;;;     				 define rule for Newton simpl. gen.
;;;     
;;;======================================================	
(defrule cauta_NSG
	(dimensiunea_sistemului  {dimens < 50 && dimens > 10})
	(jacobianul_sistemului {jacobian != 0})
	(forma_sistemului {forma == generala})
	(grad_linearitate_al_sistemului {grad_lin == oarecare})
	=>
	(assert (solutia_sistemului (solutie Newton_simpl._gen.)))
)	
;;;======================================================
;;;       
;;;     				 define rule for Linii paralele
;;;     
;;;======================================================	
(defrule cauta_LP
	(dimensiunea_sistemului  {dimens < 500 && dimens > 50 })
	(jacobianul_sistemului {jacobian > 1000})
	(forma_sistemului {forma == generala})
	(grad_linearitate_al_sistemului {grad_lin == oarecare})
	=>
	(assert (solutia_sistemului (solutie Linii_paralele)))
)
;;;======================================================
;;;       
;;;     				 define rule for Secanta
;;;     
;;;======================================================	
(defrule cauta_SC
	(dimensiunea_sistemului  {dimens     <  10 })
	(jacobianul_sistemului {jacobian != 0})
	(forma_sistemului {forma == generala})
	(grad_linearitate_al_sistemului {grad_lin == oarecare})
	=>
	(assert (solutia_sistemului (solutie Secanta)))
)
;;;======================================================
;;;       
;;;     				 define rule for Steffensen
;;;     
;;;======================================================	
(defrule cauta_STF
	(dimensiunea_sistemului  {dimens     <  10 })
	(jacobianul_sistemului {jacobian != 0})
	(forma_sistemului {forma == generala})
	(grad_linearitate_al_sistemului {grad_lin == oarecare})
	=>
	(assert (solutia_sistemului (solutie Steffensen)))
)
;;;======================================================
;;;       
;;;     				 define rule for Broyden
;;;     
;;;======================================================	
(defrule cauta_BRD
	(dimensiunea_sistemului  {dimens > 10 && dimens < 500 })
	(jacobianul_sistemului {jacobian != 0})
	(forma_sistemului {forma == generala})
	(grad_linearitate_al_sistemului {grad_lin == oarecare})
	=>
	(assert (solutia_sistemului (solutie Broyden)))
)
;;;======================================================
;;;       
;;;     				 define rule for Frideman
;;;     
;;;======================================================	
(defrule cauta_FRI
	(dimensiunea_sistemului  {dimens > 50 && dimens < 500 })
	;;;(jacobianul_sistemului {jacobian != 0})
	(forma_sistemului {forma == lacunara})
	(grad_linearitate_al_sistemului {grad_lin == oarecare})
	=>
	(assert (solutia_sistemului (solutie Frideman)))
)
;;;======================================================
;;;       
;;;     				 define rule for Gradient conjugat
;;;     
;;;======================================================	
(defrule cauta_GRD
	(dimensiunea_sistemului  {dimens > 50 && dimens < 500 })
	;;;(jacobianul_sistemului {jacobian != 0})
	(forma_sistemului {forma == lacunara})
	(grad_linearitate_al_sistemului {grad_lin == oarecare})
	=>
	(assert (solutia_sistemului (solutie Gradient_conjugat)))
)
;;;======================================================
;;;       
;;;     				 define rule for SOR simpla
;;;     
;;;======================================================	
(defrule cauta_SORS
	(dimensiunea_sistemului  {dimens > 10 && dimens < 500 })
	(jacobianul_sistemului {jacobian  > 500})
	(forma_sistemului {forma == lacunara})
	(grad_linearitate_al_sistemului {grad_lin == slab_neliniara})
	=>
	(assert (solutia_sistemului (solutie SOR_simpla)))
)
(defrule cauta_SORS2
	(dimensiunea_sistemului  {dimens > 10 && dimens < 500 })
	(jacobianul_sistemului {jacobian  > 500})
	(forma_sistemului {forma == diagonal_explicita})
	(grad_linearitate_al_sistemului {grad_lin == slab_neliniar})
	=>
	(assert (solutia_sistemului (solutie SOR_simpla)))
)
;;;======================================================
;;;       
;;;     				 define rule for SOR generala
;;;     
;;;======================================================	
(defrule cauta_SORG
	(dimensiunea_sistemului  {dimens > 50 && dimens < 500 })
	;;;(jacobianul_sistemului {jacobian != 0})
	(forma_sistemului {forma == lacunara})
	(grad_linearitate_al_sistemului {grad_lin == slab_neliniar})
	=>
	(assert (solutia_sistemului (solutie SOR_generala)))
)
;;;======================================================
;;;       
;;;     				 define rule for ADI clasica
;;;     
;;;======================================================	
(defrule cauta_ADIC
	(dimensiunea_sistemului  {dimens > 10 && dimens < 500 })
	;;;(jacobianul_sistemului {jacobian != 0})
	(forma_sistemului {forma == suma})
	(grad_linearitate_al_sistemului {grad_lin == oarecare})
	=>
	(assert (solutia_sistemului (solutie ADI_clasica)))
)
;;;======================================================
;;;       
;;;     				 define rule for ADI Kellog
;;;     
;;;======================================================	
(defrule cauta_ADIK
	(dimensiunea_sistemului  {dimens > 10 && dimens < 50 })
	;;;(jacobianul_sistemului {jacobian != 0})
	(forma_sistemului {forma == suma})
	(grad_linearitate_al_sistemului {grad_lin == oarecare})
	=>
	(assert (solutia_sistemului (solutie ADI_Kellog)))
)
;;;======================================================
;;;       
;;;     				 define rule for Speciale
;;;     
;;;======================================================	

(defrule cauta_SPEC
	(dimensiunea_sistemului  {dimens > 0 })
		=>
	(assert (solutia_sistemului (solutie Speciale)))
)
;;;======================================================
;;;       
;;;     				 execute
;;;     
;;;======================================================		  
		  
(run)

;;;======================================================
;;;       
;;;     				 exit
;;;     
;;;======================================================	  